import { AvailableTranslations } from './hooks/useAvailableTranslations.js';
import { Video } from './hooks/unstable_useVideos.js';
import { IslandWithPropsAndUrl } from './islands/constants.js';
import { PodcastShow } from './hooks/unstable_usePodcastShows.js';
import { PodcastEpisode } from './hooks/unstable_usePodcastEpisodes.js';
import { LanguageVariant } from './hooks/useLanguageVariants.js';
import type { SiteMenu } from './hooks/useMenu.js';
import type { BrandSettings } from './hooks/useBrandSettings.js';
export declare type Hublet = 'na1';
export declare type HSEnvironment = 'qa' | 'prod';
export declare type HSRenderSource = 'worker' | 'cos-renderer' | 'internal-api' | 'content-editor';
export declare type WindowPlus = typeof window & {
    __islands: Array<IslandWithPropsAndUrl>;
    __hsServerPageUrl: string;
    __hsBasePath: string;
    __hsSSInit: Record<string, any>;
    __hsSS?: Map<string, any>;
};
export declare type Override<T, O> = Omit<T, keyof O> & O;
export declare type ModuleWithDefaultExport<TModule> = {
    default: TModule;
};
export declare type DynamicImportFunc<TModule> = () => Promise<ModuleWithDefaultExport<TModule>>;
export declare type LazyModule<TModule> = {
    moduleName: string;
    moduleId: string;
} & DynamicImportFunc<TModule>;
export declare type ModuleProps<T = Record<string, any>> = {
    moduleName?: string;
    fieldValues: T;
    hublParameters: Record<string, any>;
    dataQueryResult?: any;
    serverSideProps?: any;
    hublData?: any;
    experimentalHublData?: any;
    supplementalFieldValues?: Record<string, any>;
    urlWithQuery?: string;
    urlWithoutQuery?: string;
    getServerSidePropsDependencies?: ModuleDataFetchDepsObject;
    contact?: Contact;
    request?: DataFetchRequest;
    resolvedDataDependencies?: ResolvedDataDependencies;
};
export interface DataDependencies {
    availableTranslations?: boolean;
}
declare type ResolvedAvailableTranslationsDependency = {
    type: 'success';
    data: AvailableTranslations;
} | {
    type: 'error';
    error?: string;
} | null;
declare type ResolvedLanguageVariantsDependency = {
    status: 'SUCCESS';
    data: LanguageVariant[];
} | {
    status: 'ERROR';
    error?: string;
} | {
    status: 'WARNING';
    warning?: string;
} | null;
declare type ResolvedVideoDependency = {
    status: 'success';
    ids: number[];
} | {
    status: 'error';
    ids: number[];
    error?: string;
} | null;
declare type ResolvedPodcastShowDependency = {
    status: 'success';
    ids: number[];
} | {
    status: 'error';
    ids: number[];
    error?: string;
} | null;
declare type ResolvedPodcastEpisodeDependency = {
    status: 'success';
    ids: number[];
} | {
    status: 'error';
    ids: number[];
    error?: string;
} | null;
declare type ResolvedMenuDependency = {
    status: 'success';
    id?: number;
} | {
    status: 'error';
    error?: string;
};
declare type ResolvedEditorVariableChecksDependency = {
    type: 'success';
    data: Record<string, boolean>;
} | {
    type: 'error';
    error?: string;
} | {
    type: 'deferred';
} | null;
declare type ResolvedBrandSettingsDependency = {
    type: 'success';
    data: BrandSettings;
} | {
    type: 'error';
    error?: string;
} | {
    type: 'deferred';
} | null;
export declare type ResolvedDataDependencies = {
    availableTranslations?: ResolvedAvailableTranslationsDependency;
    videos?: {
        data: Record<number, Video>;
        dependencies: Record<string, ResolvedVideoDependency>;
    };
    podcastShows?: {
        data: Record<number, PodcastShow>;
        dependencies: Record<string, ResolvedPodcastShowDependency>;
    };
    podcastEpisodes?: {
        data: Record<number, PodcastEpisode>;
        dependencies: Record<string, ResolvedPodcastEpisodeDependency>;
    };
    languageVariants?: ResolvedLanguageVariantsDependency;
    menus?: {
        data: Record<number, SiteMenu>;
        dependencies: Record<string, ResolvedMenuDependency>;
    };
    editorVariableChecks?: ResolvedEditorVariableChecksDependency;
    brandSettings?: ResolvedBrandSettingsDependency;
};
export interface CacheControlValue {
    maxAge?: number | null;
    sharedMaxAge?: number | null;
    maxStale?: boolean | null;
    maxStaleDuration?: number | null;
    minFresh?: number | null;
    immutable?: boolean | null;
    mustRevalidate?: boolean | null;
    noCache?: boolean | null;
    noStore?: boolean | null;
    noTransform?: boolean | null;
    onlyIfCached?: boolean | null;
    private?: boolean | null;
    proxyRevalidate?: boolean | null;
    public?: boolean | null;
    staleWhileRevalidate?: number | null;
    staleIfError?: number | null;
}
export declare type CachingHeaders = {
    ['Cache-Control']?: string;
    ['ETag']?: string;
    ['Last-Modified']?: string;
};
export declare type CacheConfig = {
    cacheControl?: CacheControlValue;
    lastModified?: Date | number | string;
    eTag?: string;
};
export declare type ServerSidePropsResource = {
    caching: CacheConfig;
    serverSideProps: any;
};
export declare const MAX_AGE_CACHE_FOR_AN_HOUR: CacheConfig;
export declare type URLWithoutQuery = Pick<URL, 'host' | 'hostname' | 'href' | 'origin' | 'pathname' | 'port' | 'protocol' | 'toString' | 'toJSON'> & {
    hasNoQuery: true;
};
export declare type DataFetchRequest = {
    headers: Record<string, string>;
    url: string;
};
export declare type Contact = Record<string, string> & {
    firstname?: string;
    lastname?: string;
    email?: string;
    address?: string;
};
export declare type ModuleDataFetchResult = {
    serverSideProps: Record<string, any>;
    caching: CacheConfig;
};
declare type MaybePromise<T> = T | Promise<T | undefined>;
declare const ALL_MODULE_DEPENDENCY_KINDS: readonly ["moduleProps", "urlWithoutQuery", "urlWithQuery", "contact", "fullRequest"];
export declare type ModuleDependencyKind = (typeof ALL_MODULE_DEPENDENCY_KINDS)[number];
export declare const ALL_MODULE_DATA_FETCH_DEPENDENCY_TYPES: readonly ["moduleProps", "moduleProps-urlWithoutQuery", "moduleProps-urlWithQuery", "moduleProps-urlWithQuery-contact", "moduleProps-urlWithQuery-contact-fullRequest"];
export declare type ModuleDataFetchDependency = (typeof ALL_MODULE_DATA_FETCH_DEPENDENCY_TYPES)[number];
export declare type ModuleDataFetchDepsObject = Record<ModuleDependencyKind, boolean>;
export declare const MODULE_DATA_FETCH_DEPENDENCY_AS_OBJECT: Map<"moduleProps" | "moduleProps-urlWithoutQuery" | "moduleProps-urlWithQuery" | "moduleProps-urlWithQuery-contact" | "moduleProps-urlWithQuery-contact-fullRequest", ModuleDataFetchDepsObject>;
export declare type ModulePropsWithoutSSP = Omit<ModuleProps, 'serverSideProps'>;
declare type UrlWithoutQueryDep = {
    url: URLWithoutQuery;
};
declare type UrlWithQueryDep = {
    url: URL;
};
declare type UrlAndContactDep = UrlWithQueryDep & {
    contact: Contact;
};
declare type UrlContactAndRequestDep = UrlAndContactDep & {
    request: DataFetchRequest;
};
export declare type ExtraSSPDeps = Partial<UrlContactAndRequestDep>;
export declare type ModuleDataFetchFuncByDependency = {
    moduleProps: (props: ModulePropsWithoutSSP) => MaybePromise<ModuleDataFetchResult>;
    'moduleProps-urlWithoutQuery': (props: ModulePropsWithoutSSP, extraDeps: UrlWithoutQueryDep) => MaybePromise<ModuleDataFetchResult>;
    'moduleProps-urlWithQuery': (props: ModulePropsWithoutSSP, extraDeps: UrlWithQueryDep) => MaybePromise<ModuleDataFetchResult>;
    'moduleProps-urlWithQuery-contact': (props: ModulePropsWithoutSSP, extraDeps: UrlAndContactDep) => MaybePromise<ModuleDataFetchResult>;
    'moduleProps-urlWithQuery-contact-fullRequest': (props: ModulePropsWithoutSSP, extraDeps: UrlContactAndRequestDep) => MaybePromise<ModuleDataFetchResult>;
};
export {};
